package com.kabuda.hot100.链表.medium;


/**
 * @author kabuda
 * @Description
 * @create 2025-02-18 14:09
 * 给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。
 * 请你将两个数相加，并以相同形式返回一个表示和的链表。
 * 你可以假设除了数字 0 之外，这两个数都不会以 0 开头。
 */
public class t2_两数相加 {

    public static void main(String[] args) {
        ListNode headNode = new ListNode(1);
        ListNode listNode2 = new ListNode(2);
        ListNode listNode3 = new ListNode(4);
        headNode.next = listNode2;
        listNode2.next = listNode3;

        ListNode listNode4 = new ListNode(1);
        ListNode listNode5 = new ListNode(3);
        ListNode listNode6 = new ListNode(4);
        listNode4.next = listNode5;
        listNode5.next = listNode6;


        System.out.println(addTwoNumbers(headNode, listNode4));
    }


    /**
     * @author kabuda
     * @date 2025/2/22 16:34
     * @param l1
     * @param l2
     * @return
     * @description 对齐逐步处理
     */
    public static ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        ListNode result = new ListNode(), cur = result;
        boolean flag = false;
        while (l1 != null && l2 != null) {
            //当前值
            int plusVal = l1.val + l2.val;
            //判断上一轮是否进1
            if (flag) {
                plusVal++;
            }
            //如果当前加和大于10，则进位，并且设置进位为true
            if (plusVal >= 10) {
                flag = true;
            } else {
                flag = false;
            }
            //取模求出当前位数
            int currentVal = plusVal % 10;
            //将当前值构建链表
            ListNode listNode = new ListNode(currentVal);
            cur.next = listNode;
            cur = cur.next;

            l1=l1.next;
            l2=l2.next;
        }

        //处理剩余节点
        ListNode temp=l1==null?l2:l1;
        while (temp != null) {
            //当前值
            int plusVal = temp.val;
            //判断上一轮是否进1
            if (flag) {
                plusVal++;
            }
            //如果当前加和大于10，则进位，并且设置进位为true
            if (plusVal >= 10) {
                flag = true;
            } else {
                flag = false;
            }
            //取模求出当前位数
            int currentVal = plusVal % 10;
            //将当前值构建链表
            ListNode listNode = new ListNode(currentVal);
            cur.next = listNode;
            cur = cur.next;
            temp=temp.next;
        }

        //如果最后一次进位，则构建一个1
        if (flag) {
            ListNode listNode = new ListNode(1);
            cur.next = listNode;
        }

        return result.next;
    }



    /**
     * @author kabuda
     * @date 2025/2/22 16:34
     * @param l1
     * @param l2
     * @return
     * @description 对齐逐步处理,一次遍历
     */
    public static ListNode addTwoNumbers1(ListNode l1, ListNode l2) {
        ListNode result = new ListNode(), cur = result;
        boolean flag = false;
        while (l1 != null || l2 != null) {
            int val1=l1==null?0:l1.val;
            int val2=l2==null?0:l2.val;
            //当前值
            int plusVal = val1 + val2;
            //判断上一轮是否进1
            if (flag) {
                plusVal++;
            }
            //如果当前加和大于10，则进位，并且设置进位为true
            if (plusVal >= 10) {
                flag = true;
            } else {
                flag = false;
            }
            //取模求出当前位数
            int currentVal = plusVal % 10;
            //将当前值构建链表
            ListNode listNode = new ListNode(currentVal);
            cur.next = listNode;
            cur = cur.next;

            if(l1!=null){
                l1=l1.next;
            }
            if(l2!=null){
                l2=l2.next;
            }
        }

        //如果最后一次进位，则构建一个1
        if (flag) {
            ListNode listNode = new ListNode(1);
            cur.next = listNode;
        }

        return result.next;
    }
}






